home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / language / embedded / 68hc11 / fuzzy11a.arc / FUZZY11A.ASM next >
Assembly Source File  |  1991-12-04  |  9KB  |  241 lines
  1. *    Fuzzy Logic Inferrence Engine
  2. *
  3. *** Data structures and variables
  4. *
  5.     ORG    $0000        ;Beginning of HC11 RAM
  6. CURRENT_INS RMB    8        ;Storage for 8 8-bit inputs
  7. FUZ_OUTS    RMB    32        ;Storage for fuzzy outputs
  8. COG_OUTS    RMB    4        ;Defuzzified outputs
  9. LOWEST_IF RMB    1        ;Holds min grade of IF parts
  10. SUM_OF_FUZ RMB    2        ;11-bit sum of fuzzy outs
  11. SUM_OF_PROD RMB    3        ;19-bit sum of products
  12. COGDEX    RMB    1        ;Current out # for COG loop 0->4
  13. SUMDEX    RMB    1        ;Index for sum loop 8->0
  14.  
  15.     ORG    $B600        Beginning of HC11 EEPROM
  16. IN_MF_PTRS FDB    IN0MF        ;Addr of MF data for input 0
  17.     FDB    IN1MF        ;Addr of MF data for input 1
  18.     FDB    IN2MF        ;Addr of MF data for input 2
  19.     FDB    IN3MF        ;Addr of MF data for input 3
  20.     FDB    IN4MF        ;Addr of MF data for input 4
  21.     FDB    IN5MF        ;Addr of MF data for input 5
  22.     FDB    IN6MF        ;Addr of MF data for input 6
  23.     FDB    IN7MF        ;Addr of MF data for input 7
  24. *
  25. * Input membership functions are defined by four 8-bit values per
  26. * input label. Up to 8 labels per input so max size of MF data
  27. * structure is 8*8*4=256 bytes. Unused labels take no space.
  28. * Membership functions are trapezoids with the base greater than or
  29. * equal to the top. Values are entered into this program as the
  30. * X coordinates of 4 points but are stored as 2 points and 2 slopes.
  31. * 
  32. ***** MACRO Definition for input membership functions
  33. *
  34. INMF    MACR    ;For input membership functions
  35.     FCB    \0                        ;First inflection point
  36.     IFNE \1-\0                      ;Check for divide by zero
  37.      FCB    ($FF+((\1-\0)/3))/(\1-\0) ;If not, calc slope
  38.     ENDC
  39.     IFEQ \1-\0                      ;Check for divide by zero
  40.      FCB    $00                        ;Indicates vertical slope
  41.     ENDC
  42.     FCB    \2                        ;Third inflection point
  43.     IFNE \3-\2                      ;Check for divide by zero
  44.      FCB    ($FF+((\3-\2)/3))/(\3-\2) ;If not, calc slope
  45.     ENDC
  46.     IFEQ \3-\2                      ;Check for divide by zero
  47.      FCB    $00                        ;Indicates vertical slope
  48.     ENDC
  49.     ENDM
  50. *    
  51. *****
  52. INPUT_MFS EQU    *           ;Input membership functions
  53.  
  54. IN0MF    EQU    *                 ;(0) ROTATION
  55.     INMF    0,0,0,8*4             ;    (0) STOPPED
  56.     INMF    0,8*4,$FF,$FF        ;    (1) NOT_STOPPED
  57.  
  58. IN1MF    EQU    *                 ;(1) EXAMPLE1
  59.     INMF    $20,$40,$60,$A0      ;    (0) TEST1
  60.  
  61. IN2MF    EQU    *                 ;(2) TEMPERATURE
  62.     INMF    2*0,2*0,2*40,2*50       ;    (0) COLD
  63.     INMF    2*40,2*50,2*60,2*70  ;    (1) COOL
  64.     INMF    2*60,2*70,2*80,2*90  ;    (2) WARM
  65.     INMF    2*80,2*90,2*95,2*110 ;    (3) HOT
  66.     INMF    2*90,2*110,$FF,$FF   ;    (4) VERY_HOT
  67.  
  68. IN3MF    EQU    *                 ;(3) DAYS_SINCE_RAIN
  69.     INMF    $00,$00,$00,$08       ;    (0) NONE
  70.     INMF    $00,$10,$10,$18       ;    (1) SHORT
  71.     INMF    $10,$20,$28,$40       ;    (2) MEDIUM
  72.     INMF    $30,$40,$50,$60       ;    (3) LONG
  73.     INMF    $50,$70,$FF,$FF       ;    (4) VERY_LONG
  74.  
  75. IN4MF    EQU    *        ;Not used
  76. IN5MF    EQU    *        ;Not used
  77. IN6MF    EQU    *        ;Not used
  78. IN7MF    EQU    *        ;Not used
  79.  
  80. SGLTN_POS EQU    *        ;Output singleton positions
  81. OUT0MF    EQU    *        ;(0) WATERING_TIME
  82.     FCB    $00            ;(0) CUT_OFF
  83.     FCB    $10            ;(1) DECREASE_GREATLY
  84.     FCB    $40            ;(2) DECREASE
  85.     FCB    $80            ;(3) NORMAL
  86.     FCB    $B0            ;(4) INCREASE
  87.     FCB    $F0            ;(5) INCREASE_GREATLY
  88.     FCB    0,0        ;Unused; Must fill 8 per output
  89. OUT1MF    FCB    0,0,0,0,0,0,0,0    ;Not used
  90. OUT2MF    FCB    0,0,0,0,0,0,0,0    ;Not used
  91. OUT3MF    FCB    0,0,0,0,0,0,0,0    ;Not used
  92. *
  93. * Each If part is of the form 00AA AXXX where AAA is a label (0-7)
  94. * and XXX is an input (0-7). If parts are connected by ANDs. A rule
  95. * may have any number of if parts (usually 2-8). Then parts are of
  96. * the form 100Y YCCC where the MSB set indicates a then part, YY is
  97. * the output number (0-3), and CCC is the output label (singleton
  98. * 0-7). A rule may have any number of then parts (usually 1 or 2).
  99. * A $FF indicates the end of a series of rules (number not limited).
  100. *  
  101. *    FCB    INx + 8*LABa    ;If input XXX is label AAA
  102. *    FCB    $80+8*OUTy+LABc    ;Then output YY is label CCC
  103.  
  104. RULE_START EQU    *        ;Start of first rule
  105. * Example rule: If TEMPERATURE is VERY_HOT and DAYS_SINCE_RAIN is LONG
  106. * Then WATERING_TIME is INCREASE_GREATLY
  107. RULE_1    FCB    2+(8*4),3+(8*3),$80+(8*0)+5
  108. END_OF_RULE FCB    $FF
  109.  
  110. ***** Fuzzy Inferrence Engine Starts Here
  111. *
  112.     ORG    $B66B
  113. INFER_TOP LDX    #FUZ_OUTS    ;Point at first fuzzy output
  114.     LDAA    #32        ;32 fuzzy outputs
  115. CLR_OUTS    CLR    0,X        ;Clear a fuzzy output
  116.     INX            ;Point at next
  117.     DECA            ;Loop index
  118.     BNE    CLR_OUTS        ;Continue till all fuzzy outs 0
  119.     LDY    #RULE_START    ;Point to start of 1st rule
  120. RULE_TOP    LDAA    #$FF        ;Begin processing rule string
  121.     STAA    LOWEST_IF    ;Will hold grade of min if part
  122. IF_LOOP    LDAB    0,Y        ;Get rule byte 00AA AXXX; If X is A
  123.     BMI    THEN_LOOP    ;If MSB=1, exit to then loop
  124.     LDX    #CURRENT_INS    ;Point at current input data area
  125.     ANDB    #$07        ;Save only input number
  126.     PSHB            ;Will need input # again
  127.     ABX            ;Point to specific input data
  128.     LDAA    0,X        ;Get current input data
  129.     LDX    #IN_MF_PTRS    ;Point at offsets for input MFs
  130.     PULB            ;Recover input number 0000 0XXX
  131.     ABX            ;Point at pointer for this input #
  132.     LDX    0,X        ;Get pointer into MF data area
  133.     LDAB    0,Y        ;Get rule if part 00AA AXXX
  134.     ANDB    #$38        ;00AA A000 is 8 times AAA
  135.     LSRB            ;000A AA00 4 times AAA
  136.     ABX            ;X points at MF points & slopes
  137.     CMPA    0,X        ;Compare input data to MF pt1
  138.     BHS    NOT_SEG0        ;Branch if not segment zero
  139.     CLRB            ;In seg 0 grade is zero
  140.     BRA    HAVE_GRADE    ;Have grade of membership
  141. NOT_SEG0    CMPA    2,X        ;Compare input data to MF pt2
  142.     BHI    IS_SEG2        ;Branch if segment two
  143.     LDAB    1,X        ;Slope1 -> B
  144.     BEQ    JAM_FF        ;If vert slope, jam $FF
  145.     SUBA    0,X        ;Input value - pt1 -> A
  146.     MUL            ;Grade in B if D < $100
  147.     CPD    #$100        ;Check for overflow
  148.     BLO    HAVE_GRADE    ;If < $100 grade OK in B
  149. JAM_FF    LDAB    #$FF        ;Else limit B to $FF
  150.     BRA    HAVE_GRADE    ;Have grade of membership
  151. IS_SEG2    LDAB    3,X        ;Slope2 -> B
  152.     SUBA    2,X        ;Input value - pt2 -> A
  153.     MUL            ;Grade in B if D < $100
  154.     CPD    #$100        ;Check for overflow
  155.     BLO    B_OK        ;If < $100 value in B OK
  156.     LDAB    #$FF        ;Else limit B to $FF
  157. B_OK    LDAA    #$FF        ;Grade should be $FF - (B)
  158.     SBA            ;Grade of membership in B
  159. HAVE_GRADE CMPB    LOWEST_IF    ;Is grade lowest so far ?
  160.     BHS    NOT_LOWR        ;Branch if not lower
  161.     STAB    LOWEST_IF    ;If lower, replace lowest if
  162.     BNE    NOT_LOWR        ;Skip ahead if not zero
  163. FIND_THEN INY            ;Adv rule pointer to then part
  164.     LDAB    0,Y        ;Get next rule byte
  165.     BPL    FIND_THEN    ;MSB set means its a then part
  166. FIND_IF    INY            ;Adv rule pointer to if part
  167.     LDAB    0,Y        ;Get next rule byte
  168.     BPL    RULE_TOP        ;MSB clear means its an if part
  169.     CMPB    #$FF        ;$FF is no more rules marker
  170.     BNE    FIND_IF        ;Continue looking for if or $FF
  171.     BRA    DEFUZ        ;When all rules done, go defuzzify
  172. NOT_LOWR    INY            ;Point to next rule byte
  173.     BRA    IF_LOOP        ;Continue for all if parts
  174. THEN_LOOP LDX    #FUZ_OUTS    ;Point at fuzzy outputs
  175.     ANDB    #$1F        ;Save 8 times out # + label #
  176.     ABX            ;X points at fuzzy output
  177.     LDAA    LOWEST_IF    ;Grade of membership for rule
  178.     CMPA    0,X        ;Compare to fuzzy output
  179.     BLO    NOT_HIER        ;Branch if not higher
  180.     STAA    0,X        ;Grade is higher so update
  181. NOT_HIER    INY            ;Point to next rule byte
  182.     LDAB    0,Y        ;Get rule byte
  183.     BMI    CHK_END        ;If MSB=0 its a new rule
  184.     JMP    RULE_TOP        ;Else process next rule byte
  185. CHK_END    CMPB    #$FF        ;Check for end of rules flag
  186.     BNE    THEN_LOOP    ;If not $FF, must be a then part
  187. DEFUZ    LDY    #SGLTN_POS    ;Point at 1st output singleton
  188.     LDX    #FUZ_OUTS    ;Point at 1st fuzzy output
  189.     CLR    COGDEX        ;Loop index will run from 0->4
  190. COG_LOOP    LDAB    #8        ;8 fuzzy outs per COG output
  191.     STAB    SUMDEX        ;Inner loop runs 8->0
  192.     LDD    #$0000        ;Used for quicker clears
  193.     STD    SUM_OF_FUZ    ;Sum of fuzzy outputs
  194.     STD    SUM_OF_PROD+1    ;Low 16-bits of sum of products
  195.     STAA    SUM_OF_PROD    ;Upper 8-bits
  196. SUM_LOOP    LDAB    0,X        ;Get a fuzzy output
  197.     CLRA            ;Clear upper 8-bits
  198.     ADDD    SUM_OF_FUZ    ;Add to sum of fuzzy outputs
  199.     STD    SUM_OF_FUZ    ;Update RAM variable
  200.     LDAA    0,X        ;Get fuzzy output again
  201.     LDAB    0,Y        ;Get Output singleton position
  202.     MUL            ;Position times weight
  203.     ADDD    SUM_OF_PROD+1    ;Low 16-bits of sum of products
  204.     STD    SUM_OF_PROD+1    ;Update low 16-bits
  205.     LDAA    SUM_OF_PROD    ;Upper 8-bits
  206.     ADCA    #0        ;Add carry from 16-bit add
  207.     STAA    SUM_OF_PROD    ;Upper 8-bits of 24-bit sum
  208.     INY            ;Point at next singleton pos.
  209.     INX            ;Point at next fuzzy output
  210.     DEC    SUMDEX        ;Inner loop index
  211.     BNE    SUM_LOOP        ;For all labels this output
  212.     PSHX            ;Save index for now
  213.     CLRA            ;In case divide by zero
  214.     LDX    SUM_OF_FUZ    ;Demominator for divide
  215.     BEQ    SAV_OUT        ;Branch if denominator is 0
  216.     TST    SUM_OF_PROD    ;See if more than 16-bit
  217.     BNE    NUM_BIG        ;If not zero, # is > 16-bits
  218.     LDD    SUM_OF_PROD+1    ;Numerator for divide
  219.     IDIV            ;Result in low 8-bits of X
  220.     XGDX            ;Result now in B
  221.     TBA            ;Move result to A
  222.     BRA    SAV_OUT        ;Go save output
  223. NUM_BIG    LDD    SUM_OF_PROD    ;Numerator upper 16 of 24-bit
  224.     TST    SUM_OF_PROD+2    ;Check for rounding error
  225.     BPL    NO_ROUND        ;If MSB clear, don't round
  226.     ADDD    #1        ;Round numerator up 1
  227. NO_ROUND    FDIV            ;D/X -> X, use upper 8 of 16
  228.     XGDX            ;Result now in A
  229. SAV_OUT    LDX    #COG_OUTS    ;Point to 1st defuz output
  230.     LDAB    COGDEX        ;Curent output number
  231.     ABX            ;Point to correct output
  232.     STAA    0,X        ;Update defuzzified output
  233.     PULX            ;Recover index
  234.     INCB            ;Increment loop index
  235.     STAB    COGDEX        ;Update
  236.     CMPB    #4        ;Done with all four outs?
  237.     BNE    COG_LOOP        ;If not, continue loop
  238.  
  239. * Inference engine has completed one pass of all rules.
  240.  
  241.